Developers and operators working in programmatic environments (e.g., a computing and/or processing environment capable of executing one or more methods of a program, service, etc.) are constantly challenged to isolate root causes of errors that invariably occur in the execution of methods in these environments. For simple sets of methods, the challenge is less daunting, however, when hundreds, if not, thousands of methods having asynchronous dependencies on each other are executed as part of a program, service, etc., the challenge can cause substantial inefficiencies. If such errors are not easily identified during the development/operation of such methods, the reliability, usability, and performance of resultant sets of methods, when executed, can completely barricade the development of a software project.
Operatively, when software systems (e.g., as expressed as a set of methods) misbehave, developers and operators most commonly rely on various runtime logs to troubleshoot and diagnose these problems. Generating logs involves an inherent tradeoff between logging sufficient detail to locate the root cause of problems and the prohibitive runtime cost of adding detailed logs. Developers often err on the side of inclusion of a larger set of logs than may be necessary to optimally execute the methods in the programmatic environment. Moreover, having a larger set of what may be considered as unnecessary logs may result in diminished usability and/or performance of the software system.
A current practice to ameliorate the overhead caused by the implementation of excessive logging is the use of dynamic instrumentation that lets developers collect log data at target trace-points for a short period of time. However, such a practice requires the developer to specify where (e.g., at what methods) to collect log data and, moreover, to observe the misbehavior during method execution to interactively enable/disable logging.
A more advantageous approach to achieve optimal error detection in programmatic environments considers the use of automatic logging only when a programmatic execution error occurs and only for the methods whose execution causes the error. Such an approach, as expressed by the systems and methods of the current disclosure, substantially improves on current practices and reduces the challenges faced by developers and operators alike in achieving optimal error detection in programmatic environments.
It is with respect to these considerations and others that the disclosure made herein is presented.